home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / OTHER_LA / QUINTA / MSGRESP_.C < prev    next >
Text File  |  1990-08-16  |  8KB  |  354 lines
  1. /*
  2.  * Quinta    ⌐ 1990    Eric W. Sink
  3.  *
  4.  * Responses for classes:    Message, Response
  5.  *
  6.  */
  7.  
  8. #include    "Q_includes.h"
  9.  
  10. /*--------------------------------------------------------------------*/
  11. int                         setcode_ptr_response_lang(blockparm)
  12.     MessageHandle              **blockparm;
  13. {
  14.     ResponseHandle                r;
  15.     long                        x;
  16.     x = popint();
  17.     r = popresp();
  18.     (**r).code = (int (*) ()) x;
  19. }
  20. /*--------------------------------------------------------------------*/
  21. int                         getcode_response_lang(blockparm)
  22.     MessageHandle              **blockparm;
  23. {
  24.     ResponseHandle                r;
  25.     r = popresp();
  26.     newintnum((long) (**r).code);
  27.     toptr2_integer_lang(NULL);
  28. }
  29. /*--------------------------------------------------------------------*/
  30. int                         compileit_response_lang(blockparm)
  31.     MessageHandle              **blockparm;
  32. {
  33.     ResponseHandle                r;
  34.     r = popresp();
  35.     MemCompile(r);
  36. }
  37. /*--------------------------------------------------------------------*/
  38. int                         uncompileit_response_lang(blockparm)
  39.     MessageHandle              **blockparm;
  40. {
  41.     ResponseHandle                r;
  42.     r = popresp();
  43.     if (GetPtrSize((Ptr) (**r).code))
  44.     {
  45.         DisposPtr((Ptr) (**r).code);
  46.     }
  47.     (**r).code = RespSend;
  48. }
  49. /*--------------------------------------------------------------------*/
  50. int                         getblock_response_lang(blockparm)
  51.     MessageHandle              **blockparm;
  52. {
  53.     ResponseHandle                r;
  54.     ObjectHandle                b;
  55.     r = popresp();
  56.     b = new_object(block_cp);
  57.     (**b).data = (**r).numparms;
  58.     (**b).members = (ObjectHandle **) (**r).parms;
  59.     push(b);
  60. }
  61. /*--------------------------------------------------------------------*/
  62. int                         msg_response_lang(blockparm)
  63.     MessageHandle              **blockparm;
  64. {
  65.     ResponseHandle                r;
  66.     r = popresp();
  67.     pushmessage((**r).message);
  68. }
  69. /*--------------------------------------------------------------------*/
  70. int                         execute_response_lang(blockparm)
  71.     MessageHandle              **blockparm;
  72. {
  73.     execute(popresp());
  74. }
  75. /*--------------------------------------------------------------------*/
  76. int                         comment_message_string_lang(blockparm)
  77.     MessageHandle              **blockparm;
  78. {
  79.     QStr                        str;
  80.     MessageHandle                msg;
  81.     msg = popmsg();
  82.     str = popstr();
  83.     if (((**msg).comment))
  84.     {
  85.         DropHandle((void **) ((**msg).comment));
  86.     }
  87.     (**msg).comment = str;
  88. }
  89. /*--------------------------------------------------------------------*/
  90. int                         tostr_message_lang(blockparm)
  91.     MessageHandle              **blockparm;
  92. {
  93.     MessageHandle                msg;
  94.     msg = popmsg();
  95.     newQstring((**msg).name);
  96. }
  97. /*--------------------------------------------------------------------*/
  98. int                         send_message_lang(blockparm)
  99.     MessageHandle              **blockparm;
  100. {
  101.     SendMessageM(popmsg());
  102. }
  103. /*--------------------------------------------------------------------*/
  104. int                         stopwatch_message_lang(blockparm)
  105.     MessageHandle              **blockparm;
  106. {
  107.     register MessageHandle x;
  108.     register long time1;
  109.     register long time2;
  110.     x = popmsg();
  111.     
  112.     time1 = TickCount();
  113.     SendMessageM(x);
  114.     time2 = TickCount();
  115.     newfloatnum((FPTYPE) (time2 - time1) / 60);
  116.     OutputCString(" ; ");
  117.     SendMessage(">str");
  118.     newQstringp(" seconds");
  119.     SendMessage("+");
  120.     SendMessage("print");
  121.     OutputLn();
  122. }
  123. /*--------------------------------------------------------------------*/
  124. int                         searchlength_message_lang(blockparm)
  125.     MessageHandle              **blockparm;
  126. {
  127.     MessageHandle                b;
  128.     b = popmsg();
  129.     newintnum((**b).TableIndex - Hash1((**b).name));
  130. }
  131. /*--------------------------------------------------------------------*/
  132. int                         purge_message_lang(blockparm)
  133.     MessageHandle              **blockparm;
  134. {
  135.     MessageHandle                b;
  136.     b = popmsg();
  137.     killmessage((**b).name);
  138. }
  139. /*--------------------------------------------------------------------*/
  140. int                         order_message_lang(blockparm)
  141.     MessageHandle              **blockparm;
  142. {
  143.     MessageHandle                b;
  144.     b = popmsg();
  145.     newintnum((long) (**b).order);
  146. }
  147. /*--------------------------------------------------------------------*/
  148. int                         print_message_lang(blockparm)
  149.     MessageHandle              **blockparm;
  150. {
  151.     MessageHandle                b;
  152.     ClassHandle                 c;
  153.     long                        index;
  154.     long                        ndx;
  155.     b = popmsg();
  156.     if (b)
  157.     {
  158.         OutputLn();
  159.         OutputCString(" ; '");
  160.         OutputCStringH((**b).name);
  161.         OutputCString("': ");
  162.         OutputCString("  order: ");
  163.         OutputLong((**b).order);
  164.         OutputCString(" ; # responses: ");
  165.         OutputLong((long) (**b).RespCount);
  166.         OutputLn();
  167.         if ((**b).comment)
  168.         {
  169.             OutputCString(" ; ");
  170.             OutputCStringH((**b).comment);
  171.             OutputLn();
  172.         }
  173.         OutputCString(" ; Responders: ");
  174.         OutputLn();
  175.         if ((**b).responselist)
  176.         {
  177.             PrintResps((**b).responselist);
  178.         }
  179.         else if ((**b).single)
  180.         {
  181.             OutputSet((**((**b).single)).HomesIndex, (**b).order);
  182.         }
  183.     }
  184. }
  185. /*--------------------------------------------------------------------*/
  186. int                         PrintResps(root)
  187.     RespTagHandle                root;
  188. {
  189.     long                        ndx;
  190.     MessageHandle                b;
  191.     if ((**root).left)
  192.     {
  193.         PrintResps((**root).left);
  194.     }
  195.     ndx = (**root).index;
  196.     b = (**((**root).r)).message;
  197.     if (!Inherited1(b, ndx))
  198.     {
  199.         OutputCString("               ");
  200.         OutputSet(ndx, (**b).order);
  201.         OutputLn();
  202.     }
  203.     if ((**root).right)
  204.     {
  205.         PrintResps((**root).right);
  206.     }
  207. }
  208. /*--------------------------------------------------------------------*/
  209. int                         PushResponses(tree)
  210.     RespTagHandle                tree;
  211. {
  212.     register ResponseHandle     resp;
  213.     register int                count;
  214.     count = 0;
  215.     if ((**tree).left)
  216.     {
  217.         count += PushResponses((**tree).left);
  218.     }
  219.     if ((**tree).right)
  220.     {
  221.         count += PushResponses((**tree).right);
  222.     }
  223.     resp = (**tree).r;
  224.     if (!Inherited1((**resp).message, (**tree).index))
  225.     {
  226.         pushnewresponse((**tree).r);
  227.         count++;
  228.     }
  229.     return count;
  230. }
  231. /*--------------------------------------------------------------------*/
  232. int                         responses_message_lang(blockparm)
  233.     MessageHandle              **blockparm;
  234. {
  235.     MessageHandle                b;
  236.     ClassHandle                 c;
  237.     ResponseHandle                r;
  238.     long                        ndx;
  239.     long                        numr;
  240.     b = popmsg();
  241.     if (b)
  242.     {
  243.         if ((**b).single) {
  244.             numr = 1;
  245.             pushnewresponse((**b).single);
  246.         }
  247.         else if ((**b).responselist) {
  248.             numr = PushResponses((**b).responselist);
  249.         }
  250.         newintnum(numr);
  251.         SendMessage(">list");
  252.     }
  253. }
  254. /*--------------------------------------------------------------------*/
  255. int                         print_response_lang(blockparm)
  256.     MessageHandle              **blockparm;
  257. {
  258.     MessageHandle                msg;
  259.     ResponseHandle                resp;
  260.     QInt                        np;
  261.     long                        index;
  262.  
  263.     resp = popresp();
  264.     if ((**resp).code == RespSend)
  265.     {
  266.         OutputLn();
  267.         OutputCString(" ; User defined Response: ");
  268.         if ((**resp).message)
  269.         {
  270.             OutputCStringH((**((**resp).message)).name);
  271.         }
  272.         else
  273.         {
  274.             OutputCString("BLD");
  275.         }
  276.         OutputCString(" of class: ");
  277.         OutputCStringH((**((*ClassTable)[digit((**resp).HomesIndex, 0)])).name);
  278.         OutputLn();
  279.         OutputCString("[ ");
  280.         np = 0;
  281.         while (np < (**resp).numparms)
  282.         {
  283.             msg = ((*((**((ResponseHandle) resp)).parms)))[np++];
  284.             if (msg == literal_mp)
  285.             {
  286.                 OutputCStringH((QStr) ((*((**((ResponseHandle) resp)).parms)))[np++]);
  287.                 OutputCString(" ");
  288.             }
  289.             else if (msg)
  290.             {
  291.                 OutputCStringH((**msg).name);
  292.                 OutputCString(" ");
  293.             }
  294.         }
  295.         if ((**resp).message)
  296.         {
  297.             OutputCString(" ] \r \"");
  298.             OutputCStringH((**((**resp).message)).name);
  299.             OutputCString("\" ");
  300.             if ((**resp).status & PRIVATE_MASK)
  301.             {
  302.                 OutputCString("priv ");
  303.             }
  304.             else
  305.             {
  306.                 OutputCString("pub ");
  307.             }
  308.             index = 0;
  309.             while (index < ((**((**resp).message)).order))
  310.             {
  311.                 OutputCStringH((**((*ClassTable)[digit((**resp).HomesIndex, index)])).name);
  312.                 OutputCString(" ");
  313.                 index++;
  314.             }
  315.             OutputLong(index);
  316.             OutputCString(" >list respond");
  317.             OutputLn();
  318.         }
  319.         else
  320.         {
  321.             OutputCString("BLD");
  322.         }
  323.     }
  324.     else
  325.     {
  326.         OutputLn();
  327.         OutputCString(" ; ");
  328.         OutputCStringH((**((**resp).message)).name);
  329.         OutputCString(" response CODE Addr = ");
  330.         OutputLong((long) (**resp).code);
  331.         OutputLn();
  332.     }
  333. }
  334. /*--------------------------------------------------------------------*/
  335. int                         home_response_lang(blockparm)
  336.     MessageHandle              **blockparm;
  337. {
  338.     MessageHandle                msg;
  339.     ResponseHandle                resp;
  340.     QInt                        np;
  341.     long                        index;
  342.  
  343.     resp = popresp();
  344.     index = 0;
  345.     while (index < ((**((**resp).message)).order))
  346.     {
  347.         push_class(((*ClassTable)[digit((**resp).HomesIndex, index)]));
  348.         index++;
  349.     }
  350.     newintnum(index);
  351.     SendMessage(">list");
  352. }
  353. /*--------------------------------------------------------------------*/
  354.